var express = require('express');
var router = express.Router();
const uuid = require("node-uuid");
const sql = require("../sql/sql");
const pro = require("../sql/pro");

const xlsx = require("node-xlsx");

let s = "";
let pageIndex = 0;
let dataNum = 10;
let maxPage = 1;

/* GET home page. */
router.get('/', function(req, res, next) {
  s = "";
  // 先请求数据库数据，将数据渲染到页面模板
  // sql.find(pro).then(data=>{
  //   res.render('pro', {
  //     index:1,
  //     data
  //   });
  // })

  // 修改初始数据：为第一页的数据
  let num = 10;   // 假设默认一页显示的数据条数
  let index = 0;  // 假设默认显示第0页

  pageIndex = index;
  dataNum = num;

  // 调用分页功能，传入参数，得到指定的分页数据
  sql.page(pro, {}, {}, num, index).then(data=>{
    // 获取当前集合中一共有多少条数据
    sql.count(pro).then(maxNum=>{
      maxPage = Math.ceil(maxNum/num);
      // 渲染页面模板：传入分页数据，计算之后的总页码
      res.render('pro', {
        index:1,
        data,
        maxPage:Math.ceil(maxNum/num),
        pageIndex:index,
        dataNum,
        power:req.session.power
      });
    })
  })
});

// 分页路由
router.get('/page', function(req, res, next) {
  // 接收页面发送的分页要求
  let {index=0,num=10} = req.query;
  pageIndex = index;
  dataNum = num;

  let reg = new RegExp(s);
  // 请求分页数据：注意页面过来的数据的类型
  sql.page(pro, {proName:reg}, {}, num-0, index*1).then(data=>{
    // 获取当前集合中一共有多少条数据
    sql.find(pro,{proName:reg},{}).then(data2=>{
      // 渲染页面模板：传入分页数据，计算之后的总页码，及当前的页码索引和每页的数据条数
      console.log(reg, pageIndex, dataNum, data2.length);
      res.render('pro', {
        index:1,
        data,
        maxPage:Math.ceil(data2.length / dataNum),
        pageIndex:index,  // 当前的页码索引，为了方便页面模板渲染数据的序号   和   页码按钮的当前样式
        dataNum,   // 每页的数据条数，为了页面模板渲染数据的序号
        power:req.session.power
      });
    })
  })
});


router.get('/add', function(req, res, next) {
  res.render('proAdd', {
    index:1,
    power:req.session.power
  });
});

router.post('/addAction', function(req, res, next) {

  let obj = req.body;
  obj.proId = "pro" + uuid.v1();

  obj.price = Number(obj.price);
  obj.stock = parseFloat(obj.stock);
  obj.discount = obj.discount-0;
  obj.sales = obj.sales-0;
  obj.score = obj.score*1;

  // 存储数据到数据库，并路由重定向到商品显示路由
  // console.log(obj);

  sql.insert(pro, obj).then(()=>{
    res.redirect("/pro");
  })

});

// 导入./data/pro2.xlsx文件的路由
router.get('/insertAll', function(req, res, next) {
  // 使用第三方模块解析文件
  const data = xlsx.parse("./data/pro2.xlsx");
  // console.log(data[0].data);
  var arr = [];
  // 解析数据，将数据解析成：[{},{},{},....]
  for(let i=1;i<data[0].data.length;i++){
    arr.push({
      "proId":"pro" + uuid.v1(),
      "proName":data[0].data[i][1],
      "column":data[0].data[i][2],
      "brand":data[0].data[i][3],
      "logo":data[0].data[i][4],
      "proImg":data[0].data[i][5],
      "price":data[0].data[i][6],
      "introduce":data[0].data[i][7],
      "stock":data[0].data[i][8],
      "sales":data[0].data[i][9],
      "discount":data[0].data[i][10],
      "score":data[0].data[i][11]
    })
  }
  // 将解析之后的数据，插入数据库
  sql.insert(pro,arr).then(()=>{
    // 插入成功后，路由重定向到/pro
    res.redirect("/pro");
  })
});

// 删除操作
router.get('/delete', function(req, res, next) {
  const id = req.query.id;
  sql.delete(pro, {proId:id}).then(()=>{
    res.redirect("/pro");
  })
});

// 修改操作 - 表单
router.get('/update', function(req, res, next) {
  // 接收当前商品的id
  const id = req.query.id;
  // 根据当前id查询商品数据
  sql.find(pro, {proId:id}, {_id:0,__v:0}).then(data=>{
    // 将商品数据，发送给修改表单的页面模板
    res.render("proUpdate",{
      index:1,
      data:data[0],
      power:req.session.power
    });
  })
});

// 修改操作 - 更新数据
router.post('/updateAction', function(req, res, next) {
  // 接收当前商品的数据
  const obj = req.body;
  
  // 处理数据类型，符合数据集合的字段类型
  obj.price = Number(obj.price);
  obj.stock = parseFloat(obj.stock);
  obj.discount = obj.discount-0;
  obj.sales = obj.sales-0;
  obj.score = obj.score*1;

  // 根据当前id更新商品数据
  sql.update(pro, {proId:obj.proId}, obj).then(()=>{
    // 路由重定向到商品展示页面
    res.redirect("/pro");
  })
});

// 商品排序
router.get('/sort',(req, res, next)=>{
  // 接收要排序的字段和方向
  const obj = req.query;
  // 调用排序方法（本质是查询）
  sql.sort(pro, {}, {}, obj).then(data=>{
    // 重新渲染页面，将排序之后的数据，发给页面模板
    res.render("pro",{
      index:1,
      data,
      pageIndex:0,
      dataNum:data.length,
      maxPage:1,
      power:req.session.power
    })
  })
})

// 商品搜索
router.post('/search',(req, res, next)=>{
  // 接收要搜索的数据
  const obj = req.body;

  // 根据要搜索的关键字，创建正则，准备给find方法做模糊查询的条件使用
  let reg = new RegExp(obj.search);

  s = obj.search;

  // 调用查询方法（设置查询条件为模糊查询）
  sql.page(pro, {proName:reg}, {}, 10, 0).then(data=>{
    sql.find(pro, {proName:reg}, {}).then(data2=>{
      // maxPage = Math.ceil(data2.length / dataNum)
      // 重新渲染页面，将搜索之后的数据，发给页面模板
      res.render("pro",{
        index:1,
        data,
        pageIndex:0,
        dataNum:10,
        maxPage:Math.ceil(data2.length / 10),
        power:req.session.power
      })
    })
  })
})

module.exports = router;
